home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 054 (1988-05-15)(Ossowski, Stefan)(DE)(PD).zip / Taifun 054 (1988-05-15)(Ossowski, Stefan)(DE)(PD).adf / MRBackup / MRBackup2.0 / UserPrefs.c < prev   
C/C++ Source or Header  |  1988-04-09  |  6KB  |  285 lines
  1. /* MRBackup user preferences processing.
  2.  * Filename:    UserPrefs.c
  3.  * Date:        08/23/87
  4.  *
  5.  * History:        (most recent change first)
  6.  *
  7.  * 12/20/87 -MRR- Added PutUserPrefs to allow saving new preferences.
  8.  * 11/23/87 -MRR- Version 2.0.
  9.  *
  10.  */
  11.  
  12. #include "MRBackup.h"
  13.  
  14. char *fgets();
  15.  
  16. extern struct Gadget backPathGadget;
  17. extern struct Gadget xcldPathGadget;
  18. extern struct Gadget homePathGadget;
  19. extern struct Gadget listPathGadget;
  20. extern struct Menu Menu1;
  21.  
  22. #define KEYMAX        20                /* max length of a keyword */
  23. #define NKEYWORD    9                /* number of keywords supported */
  24. #define PREFERENCES_FILE "S:MRBackup.init"
  25.  
  26. #define KW_HOME            0
  27. #define KW_BACKUP        1
  28. #define KW_LIST            2
  29. #define KW_EXCLUDE        3
  30. #define KW_COMPRESSION    4
  31. #define KW_LISTING      5
  32. #define KW_SPEECH        6
  33. #define KW_FORMAT        7
  34. #define KW_BIGFILES        8
  35.  
  36. static char *keywords[NKEYWORD] = {
  37.     "home", "backup", "list", "exclude", 
  38.     "compression", "listing", "speech",
  39.     "format","bigfiles"
  40.     };
  41.  
  42. /* Process the user preferences file. */
  43.  
  44. GetUserPrefs()
  45. {
  46.     char c;
  47.     USHORT i;
  48.     char keyword[KEYMAX+1];
  49.     short keyindex;
  50.     USHORT keyleng;
  51.  
  52.     FILE *prefs;
  53.     char s[81];
  54.     char *s1, *s2, *s3;
  55.  
  56.     if (!(prefs = fopen(PREFERENCES_FILE,"r"))) {
  57.         WriteConsole("I couldn't get your preferences.\n");
  58.         return;
  59.     }
  60.  
  61.     while (fgets(s, 80, prefs)) {
  62.         if (*s == '#') continue;
  63.         WriteConsole(s);
  64.         s1 = s;
  65.         keyleng = 0;
  66.         while ((c = *s1++) && isalpha(c)) {
  67.             if (keyleng < KEYMAX) keyword[keyleng++] = tolower(c);
  68.             else {
  69. badkey:
  70.                 WriteConsole("Keyword error in preferences file.\n");
  71. err:
  72.                 goto done;
  73.             }
  74.         }
  75.         keyword[keyleng] = '\0';
  76.         for (keyindex = -1, i = 0; i < NKEYWORD; ++i) {
  77.             if (!strcmp(keyword, keywords[i])) {
  78.                 keyindex = i;        /* found it */
  79.                 break;
  80.             }
  81.         }
  82.         if (keyindex < 0) goto badkey;
  83.         while (c == ' ' || c == '\t') c = *s1++;
  84.         if (c != '=') {
  85. badsyn:
  86.             WriteConsole("Syntax error in preferences file.\n");
  87.             goto done;
  88.         }
  89.  
  90.         /* Get the parameter field, minus any leading or trailing
  91.          * blanks.
  92.          */
  93.  
  94.         while ((c = *s1) == ' ' || c == '\t') ++s1; /* skip leading blanks */
  95.         /* Delete trailing blanks. */
  96.         s2 = s3 = s1;
  97.         while (c && c != '\n') {
  98.             if (c != ' ' && c != '\t') s2 = s3;    /* record non-blank end */
  99.             c = *s3++;
  100.         }
  101.         *s2 = '\0';                    /* truncate the string here */
  102.         SetUserPref(keyindex, s1);
  103.     }
  104. done:
  105.     fclose(prefs);
  106. }
  107.  
  108. /* Output a boolean preference setting.
  109.  * Called with:
  110.  *        f:        preferences file descriptor
  111.  *        value:    boolean value
  112.  */
  113.  
  114. PutBoolPref(f, value)
  115.     FILE *f; unsigned value;
  116. {
  117.     char *s;
  118.  
  119.     s = (value ? "YES" : "NO");
  120.  
  121.     fputs(s, f);
  122. }
  123.  
  124. /* Save the current program settings in the user preferences file. */
  125.  
  126. PutUserPrefs()
  127. {
  128.     char backupName[81];        /* backup path name */
  129.     unsigned keyIndex;
  130.     FILE *prefs;
  131.  
  132.     strcpy(backupName, PREFERENCES_FILE);
  133.     strcat(backupName, ".bak");
  134.     if ( CopyFile(PREFERENCES_FILE, backupName) )
  135.         TypeAndSpeak(
  136.         "I couldn't back up the current preferences but I'll go on.\n");
  137.  
  138.     if (!(prefs = fopen(PREFERENCES_FILE, "w") ) ) {
  139.         sprintf(conmsg,
  140. "I couldn't open the preferences file, %s, for output;\n error %d\n",
  141.         PREFERENCES_FILE, errno);
  142.         return;
  143.     }
  144.     for (keyIndex = 0; keyIndex < NKEYWORD; ++keyIndex) {
  145.         fprintf(prefs,"%s = \t\t", keywords[keyIndex]);
  146.         switch (keyIndex) {
  147.         case KW_HOME:
  148.             fputs(homePath,prefs);
  149.             break;
  150.         case KW_BACKUP:
  151.             fputs(backPath,prefs);
  152.             break;
  153.         case KW_LIST:
  154.             fputs(listPath,prefs);
  155.             break;
  156.         case KW_EXCLUDE:
  157.             fputs(excludePath,prefs);
  158.             break;
  159.         case KW_COMPRESSION:
  160.             PutBoolPref(prefs, doFormat);
  161.             break;
  162.         case KW_LISTING:
  163.             PutBoolPref(prefs, doListing);
  164.             break;
  165.         case KW_SPEECH:
  166.             PutBoolPref(prefs, doSpeech);
  167.             break;
  168.         case KW_FORMAT:
  169.             PutBoolPref(prefs, doFormat);
  170.             break;
  171.         case KW_BIGFILES:
  172.             PutBoolPref(prefs, doBigFiles);
  173.             break;
  174.         default:
  175.             sprintf(conmsg,
  176. "Program error in PutUserPrefs for keyword \"%s\".  Please report this.\n",
  177.                     keywords[keyIndex]);
  178.             TypeAndSpeak(conmsg);
  179.         }
  180.         fputs("\n", prefs);
  181.     }
  182.     fclose(prefs);
  183. }
  184.  
  185. /* Set/Clear checkmarks according to the item being set. 
  186.  * Called with:
  187.  *        thisItem:    menu item number
  188.  *        value:        character string containing some form of YES or NO
  189.  */
  190.  
  191. BOOL 
  192. SetMenuItem(itemNumber, value)
  193.     USHORT itemNumber; char *value;
  194. {
  195.     BOOL boolean;
  196.     LONG menu;
  197.     struct MenuItem *item;
  198.     short i;
  199.  
  200.     /* Get pointers and menu numbers for the affected items. */
  201.  
  202.     menu = SHIFTITEM((long) itemNumber) | SHIFTMENU((long) MENU_FLAGS);
  203.     item = ItemAddress(&Menu1, menu);
  204.  
  205.     if (item == NULL) {
  206.         WriteConsole("Null menu item in SetMenuItem - call Mark!!\n");
  207.         return false;
  208.     }
  209.  
  210.     boolean = ( tolower(*value) == 'y' );
  211.     if (boolean) {                /* true? */
  212.         item->Flags |= CHECKED;
  213.     }
  214.     else {                        /* false */
  215.         item->Flags &= ~CHECKED;
  216.     }
  217.     return boolean;
  218. }
  219.  
  220. void
  221. SetStringGadget(gadget, value)
  222.     struct Gadget *gadget; char *value;
  223. {
  224.     UBYTE *gs;                            /* pointer to gadget string */
  225.  
  226.     RemoveGadget(pathWindow, gadget);
  227.     gs = (UBYTE *) GadgetString(gadget);
  228.     strcpy(gs, value);
  229.     ResetStringInfo(gadget->SpecialInfo);
  230.     AddGadget(pathWindow, gadget, -1L);
  231.     DoGadget(pathWindow, GADGETUP, gadget);    /* simulate GADGETUP */
  232. }
  233.  
  234. /* Set one user preference item. 
  235.  * Called with:
  236.  *        kw:            keyword index
  237.  *        parm:        parameter string
  238.  */
  239.  
  240. SetUserPref(kw, parm)
  241.     USHORT kw; char *parm;
  242. {
  243.  
  244.     switch (kw) {
  245.     case KW_HOME:
  246.         SetStringGadget(&homePathGadget, parm);
  247.         break;
  248.  
  249.     case KW_BACKUP:
  250.         SetStringGadget(&backPathGadget, parm);
  251.         break;
  252.  
  253.     case KW_LIST:
  254.         SetStringGadget(&listPathGadget, parm);
  255.         break;
  256.  
  257.     case KW_LISTING:
  258.         doListing = SetMenuItem(ITEM_LIST, parm);
  259.         break;
  260.  
  261.     case KW_EXCLUDE:
  262.         SetStringGadget(&xcldPathGadget, parm);
  263.         break;
  264.  
  265.     case KW_COMPRESSION:
  266.         doCompress = SetMenuItem(ITEM_COMPRESS, parm);
  267.         break;
  268.  
  269.     case KW_SPEECH:
  270.         doSpeech = SetMenuItem(ITEM_SPEECH, parm);
  271.         break;
  272.  
  273.     case KW_FORMAT:
  274.         doFormat = SetMenuItem(ITEM_FORMAT, parm);
  275.         break;
  276.  
  277.     case KW_BIGFILES:
  278.         doBigFiles = SetMenuItem(ITEM_BIGFILES, parm);
  279.         break;
  280.     default:
  281.         break;
  282.     }
  283. }
  284.  
  285.